Beispiel: Movie-API URL-Struktur

# STANDARD CRUD
GET    /api/movies/                    # Alle Filme
POST   /api/movies/                    # Film erstellen
GET    /api/movies/{id}/               # Film-Details
PUT    /api/movies/{id}/               # Film komplett aktualisieren
PATCH  /api/movies/{id}/               # Film teilweise aktualisieren
DELETE /api/movies/{id}/               # Film löschen

# FILTERING & SEARCH
GET    /api/movies/?year=2010          # Filter nach Jahr
GET    /api/movies/?genre=Sci-Fi       # Filter nach Genre
GET    /api/movies/?search=Matrix      # Suche im Titel
GET    /api/movies/?ordering=-rating   # Sortierung nach Rating

# PAGINATION
GET    /api/movies/?page=2             # Seite 2
GET    /api/movies/?page=2&page_size=5 # 5 Einträge pro Seite

# RELATIONSHIPS
GET    /api/movies/{id}/castings/      # Besetzung eines Films
GET    /api/artists/{id}/movies/       # Filme eines Künstlers

# CUSTOM ACTIONS
GET    /api/movies/top-rated/          # Top 10 Filme
GET    /api/movies/recent/             # Aktuelle Filme
GET    /api/movies/{id}/similar/       # Ähnliche Filme

# BATCH OPERATIONS (erweitert)
POST   /api/movies/bulk-create/        # Mehrere Filme erstellen
PATCH  /api/movies/bulk-update/        # Mehrere Filme updaten
DELETE /api/movies/bulk-delete/        # Mehrere Filme löschen

Verzeichnisstruktur:

FirstMovieAPI/
├── firstmovieapi/          # Projekt-Settings
│   ├── __init__.py
│   ├── settings.py         # ← Werden wir anpassen
│   ├── urls.py             # ← Werden wir anpassen
│   └── wsgi.py
├── movies/                 # Unsere App
│   ├── __init__.py
│   ├── models.py           # ← Bereits vorhanden (Movie, Artist, MovieCasting)
│   ├── serializers.py      # ← NEU erstellen
│   ├── views.py            # ← NEU erstellen
│   ├── urls.py             # ← NEU erstellen
│   ├── admin.py
│   └── migrations/
├── manage.py
└── db.sqlite3

Unsere Models (bereits vorhanden):

class Movie(models.Model):
    title = models.CharField(max_length=200)
    year = models.IntegerField()
    genre = models.CharField(max_length=100, blank=True)
    rating = models.DecimalField(max_digits=3, decimal_places=1, null=True, blank=True)
    description = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

class Artist(models.Model):
    first_name = models.CharField(max_length=100)
    last_name = models.CharField(max_length=100)
    birth_date = models.DateField(null=True, blank=True)
    nationality = models.CharField(max_length=100, blank=True)
    biography = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

class MovieCasting(models.Model):
    movie = models.ForeignKey(Movie, on_delete=models.CASCADE, related_name='castings')
    artist = models.ForeignKey(Artist, on_delete=models.CASCADE, related_name='movie_roles')
    role_name = models.CharField(max_length=200)
    is_main_role = models.BooleanField(default=False)
    order = models.IntegerField(default=0)
    created_at = models.DateTimeField(auto_now_add=True)

firstmovieapi/settings.py anpassen:

# filepath: firstmovieapi/settings.py
# ...existing code...

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    
    # Third-party apps
    'rest_framework',        # ← NEU! Django REST Framework
    'django_filters',        # ← NEU! Filtering-Support
    'corsheaders',           # ← NEU! (optional) CORS-Support
    'drf_spectacular',       # ← NEU! (optional) API-Dokumentation
    
    # Local apps
    'movies',
]

# ...existing code...

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'corsheaders.middleware.CorsMiddleware',  # ← NEU! (optional) CORS
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

# ...existing code...

# ==============================================
# REST FRAMEWORK KONFIGURATION (am Ende der Datei)
# ==============================================

REST_FRAMEWORK = {
    # Schema-Generator (für Swagger)
    'DEFAULT_SCHEMA_CLASS': 'drf_spectacular.openapi.AutoSchema',  # optional
    
    # Permissions (Zugriffsrechte)
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.AllowAny',  # Für Development: Jeder hat Zugriff
        # In Produktion: 'rest_framework.permissions.IsAuthenticated',
    ],
    
    # Pagination (Seitennummerierung)
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 10,  # 10 Einträge pro Seite
    
    # Renderer (Output-Formate)
    'DEFAULT_RENDERER_CLASSES': [
        'rest_framework.renderers.JSONRenderer',          # JSON-Output
        'rest_framework.renderers.BrowsableAPIRenderer',  # Interaktive Web-UI
    ],
    
    # Filter Backends
    'DEFAULT_FILTER_BACKENDS': [
        'django_filters.rest_framework.DjangoFilterBackend',  # django-filter
        'rest_framework.filters.SearchFilter',                # Suche
        'rest_framework.filters.OrderingFilter',              # Sortierung
    ],
    
    # Throttling (Rate Limiting) - optional
    'DEFAULT_THROTTLE_CLASSES': [
        'rest_framework.throttling.AnonRateThrottle',   # Für anonyme User
        'rest_framework.throttling.UserRateThrottle',   # Für eingeloggte User
    ],
    'DEFAULT_THROTTLE_RATES': {
        'anon': '100/hour',   # 100 Requests pro Stunde für Anonyme
        'user': '1000/hour',  # 1000 Requests pro Stunde für User
    },
}

# ==============================================
# CORS HEADERS KONFIGURATION (optional)
# ==============================================

CORS_ALLOWED_ORIGINS = [
    "http://localhost:3000",    # React/Vue/Angular Frontend
    "http://localhost:8080",
    "http://127.0.0.1:3000",
]

# Oder für Development: ALLE Domains erlauben (NICHT in Produktion!)
# CORS_ALLOW_ALL_ORIGINS = True

# ==============================================
# DRF SPECTACULAR KONFIGURATION (optional)
# ==============================================

SPECTACULAR_SETTINGS = {
    'TITLE': 'Movie API',
    'DESCRIPTION': 'REST API für Filme, Künstler und Besetzungen',
    'VERSION': '1.0.0',
    'SERVE_INCLUDE_SCHEMA': False,
}

Erstelle: movies/serializers.py

# filepath: movies/serializers.py
from rest_framework import serializers
from .models import Movie, Artist, MovieCasting


class MovieSerializer(serializers.ModelSerializer):
    """
    Serializer für Movie Model
    Konvertiert Movie-Objekte zu JSON und validiert Input
    """
    # Berechnetes Feld: Alter des Films
    age = serializers.SerializerMethodField()
    
    class Meta:
        model = Movie
        fields = '__all__'  # Alle Felder einbeziehen
        read_only_fields = ['created_at', 'updated_at']  # Nicht änderbar
    
    def get_age(self, obj):
        """Berechne das Alter des Films"""
        from datetime import datetime
        return datetime.now().year - obj.year
    
    def validate_year(self, value):
        """Validiere das Jahr"""
        from datetime import datetime
        current_year = datetime.now().year
        
        if value < 1888:  # Erstes Kino-Jahr
            raise serializers.ValidationError(
                "Das Jahr kann nicht vor 1888 liegen (Geburt des Kinos)"
            )
        
        if value > current_year + 5:  # Max 5 Jahre in Zukunft
            raise serializers.ValidationError(
                f"Das Jahr kann nicht mehr als 5 Jahre in der Zukunft liegen"
            )
        
        return value
    
    def validate_rating(self, value):
        """Validiere die Bewertung"""
        if value is not None and (value < 0 or value > 10):
            raise serializers.ValidationError(
                "Die Bewertung muss zwischen 0 und 10 liegen"
            )
        return value


class ArtistSerializer(serializers.ModelSerializer):
    """
    Serializer für Artist Model
    """
    # Property aus Model als Read-Only Feld
    full_name = serializers.ReadOnlyField()
    
    # Berechnetes Feld: Anzahl Filme
    movie_count = serializers.SerializerMethodField()
    
    class Meta:
        model = Artist
        fields = '__all__'
        read_only_fields = ['created_at', 'updated_at']
    
    def get_movie_count(self, obj):
        """Anzahl der Filme, in denen der Künstler mitspielt"""
        return obj.movie_roles.count()


class MovieCastingSerializer(serializers.ModelSerializer):
    """
    Einfacher Casting Serializer (nur IDs)
    Für CREATE/UPDATE Operationen
    """
    class Meta:
        model = MovieCasting
        fields = '__all__'
        read_only_fields = ['created_at']


class MovieCastingDetailSerializer(serializers.ModelSerializer):
    """
    Detaillierter Casting Serializer mit verschachtelten Objekten
    Für LIST/RETRIEVE Operationen
    """
    # Verschachtelte Serializer (für Output)
    movie = MovieSerializer(read_only=True)
    artist = ArtistSerializer(read_only=True)
    
    # IDs für Input (Write-Only)
    movie_id = serializers.PrimaryKeyRelatedField(
        queryset=Movie.objects.all(),
        source='movie',
        write_only=True
    )
    artist_id = serializers.PrimaryKeyRelatedField(
        queryset=Artist.objects.all(),
        source='artist',
        write_only=True
    )
    
    class Meta:
        model = MovieCasting
        fields = '__all__'
        read_only_fields = ['created_at']

Erstelle: movies/views.py

# filepath: movies/views.py
from rest_framework import viewsets, filters, status
from rest_framework.decorators import action
from rest_framework.response import Response
from django_filters.rest_framework import DjangoFilterBackend
from .models import Movie, Artist, MovieCasting
from .serializers import (
    MovieSerializer,
    ArtistSerializer,
    MovieCastingSerializer,
    MovieCastingDetailSerializer
)


class MovieViewSet(viewsets.ModelViewSet):
    """
    ViewSet für Movie Model
    
    Bietet automatisch folgende Endpoints:
    - list (GET /api/movies/) - Alle Filme
    - create (POST /api/movies/) - Film erstellen
    - retrieve (GET /api/movies/{id}/) - Film-Details
    - update (PUT /api/movies/{id}/) - Film komplett aktualisieren
    - partial_update (PATCH /api/movies/{id}/) - Film teilweise aktualisieren
    - destroy (DELETE /api/movies/{id}/) - Film löschen
    """
    queryset = Movie.objects.all()
    serializer_class = MovieSerializer
    
    # Filter Backends
    filter_backends = [
        DjangoFilterBackend,  # Für exakte Filter
        filters.SearchFilter,  # Für Textsuche
        filters.OrderingFilter  # Für Sortierung
    ]
    
    # Welche Felder können gefiltert werden?
    filterset_fields = ['year', 'genre']  # ?year=2010&genre=Sci-Fi
    
    # Welche Felder können durchsucht werden?
    search_fields = ['title', 'description']  # ?search=Matrix
    
    # Welche Felder können sortiert werden?
    ordering_fields = ['year', 'rating', 'title']  # ?ordering=-rating
    
    # Standard-Sortierung
    ordering = ['-year', 'title']  # Neueste zuerst, dann alphabetisch
    
    @action(detail=True, methods=['get'])
    def castings(self, request, pk=None):
        """
        Custom Endpoint: GET /api/movies/{id}/castings/
        Gibt alle Besetzungen eines Films zurück
        """
        movie = self.get_object()
        castings = movie.castings.all()
        serializer = MovieCastingDetailSerializer(castings, many=True)
        return Response(serializer.data)
    
    @action(detail=False, methods=['get'])
    def top_rated(self, request):
        """
        Custom Endpoint: GET /api/movies/top_rated/
        Gibt die Top 10 bestbewerteten Filme zurück
        """
        movies = Movie.objects.filter(
            rating__isnull=False
        ).order_by('-rating')[:10]
        
        serializer = self.get_serializer(movies, many=True)
        return Response(serializer.data)
    
    @action(detail=False, methods=['get'])
    def recent(self, request):
        """
        Custom Endpoint: GET /api/movies/recent/
        Gibt Filme der letzten 5 Jahre zurück
        """
        from datetime import datetime
        current_year = datetime.now().year
        movies = Movie.objects.filter(year__gte=current_year - 5)
        
        serializer = self.get_serializer(movies, many=True)
        return Response(serializer.data)
    
    @action(detail=True, methods=['post'])
    def add_to_favorites(self, request, pk=None):
        """
        Custom Endpoint: POST /api/movies/{id}/add_to_favorites/
        Beispiel für Custom POST Action
        """
        movie = self.get_object()
        # Hier könnte Logik für Favoriten sein
        return Response({
            'status': 'Film zu Favoriten hinzugefügt',
            'movie': movie.title
        })


class ArtistViewSet(viewsets.ModelViewSet):
    """
    ViewSet für Artist Model
    """
    queryset = Artist.objects.all()
    serializer_class = ArtistSerializer
    
    filter_backends = [
        filters.SearchFilter,
        filters.OrderingFilter
    ]
    
    search_fields = ['first_name', 'last_name', 'nationality', 'biography']
    ordering_fields = ['last_name', 'first_name', 'birth_date']
    ordering = ['last_name', 'first_name']
    
    @action(detail=True, methods=['get'])
    def movies(self, request, pk=None):
        """
        Custom Endpoint: GET /api/artists/{id}/movies/
        Gibt alle Filme eines Künstlers zurück
        """
        artist = self.get_object()
        castings = artist.movie_roles.all()
        movies = [casting.movie for casting in castings]
        
        serializer = MovieSerializer(movies, many=True)
        return Response(serializer.data)
    
    @action(detail=True, methods=['get'])
    def filmography(self, request, pk=None):
        """
        Custom Endpoint: GET /api/artists/{id}/filmography/
        Detaillierte Filmografie mit Rollen
        """
        artist = self.get_object()
        castings = artist.movie_roles.all().select_related('movie')
        
        # Gruppiere nach Hauptrolle/Nebenrolle
        main_roles = castings.filter(is_main_role=True)
        supporting_roles = castings.filter(is_main_role=False)
        
        return Response({
            'artist': ArtistSerializer(artist).data,
            'main_roles': MovieCastingDetailSerializer(main_roles, many=True).data,
            'supporting_roles': MovieCastingDetailSerializer(supporting_roles, many=True).data,
            'total_movies': castings.count()
        })


class MovieCastingViewSet(viewsets.ModelViewSet):
    """
    ViewSet für MovieCasting Model
    """
    queryset = MovieCasting.objects.all().select_related('movie', 'artist')
    
    filter_backends = [DjangoFilterBackend]
    filterset_fields = ['movie', 'artist', 'is_main_role']
    
    def get_serializer_class(self):
        """
        Wähle den passenden Serializer basierend auf der Action
        """
        if self.action in ['list', 'retrieve']:
            # Für Anzeige: Mit verschachtelten Objekten
            return MovieCastingDetailSerializer
        # Für Create/Update: Nur IDs
        return MovieCastingSerializer

1. Erstelle: movies/urls.py

# filepath: movies/urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import MovieViewSet, ArtistViewSet, MovieCastingViewSet

# Router erstellen
router = DefaultRouter()

# ViewSets beim Router registrieren
router.register(r'movies', MovieViewSet, basename='movie')
router.register(r'artists', ArtistViewSet, basename='artist')
router.register(r'castings', MovieCastingViewSet, basename='casting')

# URLs
urlpatterns = [
    # Router-URLs einbinden
    path('', include(router.urls)),
]

2. Registriere in: firstmovieapi/urls.py

# filepath: firstmovieapi/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    # Django Admin
    path('admin/', admin.site.urls),
    
    # API Endpunkte
    path('api/', include('movies.urls')),
    
    # DRF Login/Logout für Browsable API
    path('api-auth/', include('rest_framework.urls')),
    
    # Optional: Swagger Dokumentation
    # path('api/schema/', SpectacularAPIView.as_view(), name='schema'),
    # path('api/docs/', SpectacularSwaggerView.as_view(url_name='schema'), name='swagger-ui'),
]

Für komplexere Filter: FilterSet-Klasse erstellen

# filepath: movies/filters.py
import django_filters
from .models import Movie


class MovieFilter(django_filters.FilterSet):
    """Custom Filter für Movie Model"""
    
    # Jahr-Range
    year_min = django_filters.NumberFilter(field_name='year', lookup_expr='gte')
    year_max = django_filters.NumberFilter(field_name='year', lookup_expr='lte')
    
    # Rating-Range
    rating_min = django_filters.NumberFilter(field_name='rating', lookup_expr='gte')
    rating_max = django_filters.NumberFilter(field_name='rating', lookup_expr='lte')
    
    # Genre mit Case-Insensitive
    genre = django_filters.CharFilter(lookup_expr='icontains')
    
    # Titel enthält
    title_contains = django_filters.CharFilter(field_name='title', lookup_expr='icontains')
    
    # Nur Filme mit Rating
    has_rating = django_filters.BooleanFilter(field_name='rating', lookup_expr='isnull', exclude=True)
    
    class Meta:
        model = Movie
        fields = ['genre']

In ViewSet verwenden:

# filepath: movies/views.py
from .filters import MovieFilter

class MovieViewSet(viewsets.ModelViewSet):
    queryset = Movie.objects.all()
    serializer_class = MovieSerializer
    filterset_class = MovieFilter  # ← Custom FilterSet
    # ...existing code...

Verwendung:

GET /api/movies/?year_min=2010&year_max=2020
GET /api/movies/?rating_min=8.0
GET /api/movies/?title_contains=matrix
GET /api/movies/?has_rating=true
GET /api/movies/?genre=sci&year_min=2010&rating_min=8.0

# filepath: movies/models.py
from django.db import models

class Movie(models.Model):
    """Model für Filme"""
    title = models.CharField(max_length=200, verbose_name="Titel")
    year = models.IntegerField(verbose_name="Erscheinungsjahr")
    genre = models.CharField(max_length=100, verbose_name="Genre", blank=True)
    rating = models.DecimalField(
        max_digits=3, 
        decimal_places=1, 
        null=True, 
        blank=True, 
        verbose_name="Bewertung"
    )
    description = models.TextField(verbose_name="Beschreibung", blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        verbose_name = "Film"
        verbose_name_plural = "Filme"
        ordering = ['-year', 'title']
    
    def __str__(self):
        return f"{self.title} ({self.year})"


class Artist(models.Model):
    """Model für Schauspieler/Künstler"""
    first_name = models.CharField(max_length=100, verbose_name="Vorname")
    last_name = models.CharField(max_length=100, verbose_name="Nachname")
    birth_date = models.DateField(verbose_name="Geburtsdatum", null=True, blank=True)
    nationality = models.CharField(max_length=100, verbose_name="Nationalität", blank=True)
    biography = models.TextField(verbose_name="Biografie", blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        verbose_name = "Künstler"
        verbose_name_plural = "Künstler"
        ordering = ['last_name', 'first_name']
    
    def __str__(self):
        return f"{self.first_name} {self.last_name}"
    
    @property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"


class MovieCasting(models.Model):
    """Brückentabelle: Welcher Artist spielt in welchem Movie"""
    movie = models.ForeignKey(
        Movie, 
        on_delete=models.CASCADE, 
        related_name='castings', 
        verbose_name="Film"
    )
    artist = models.ForeignKey(
        Artist, 
        on_delete=models.CASCADE, 
        related_name='movie_roles', 
        verbose_name="Künstler"
    )
    role_name = models.CharField(max_length=200, verbose_name="Rollenname")
    is_main_role = models.BooleanField(default=False, verbose_name="Hauptrolle")
    order = models.IntegerField(default=0, verbose_name="Reihenfolge")
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        verbose_name = "Besetzung"
        verbose_name_plural = "Besetzungen"
        ordering = ['order', 'artist__last_name']
        unique_together = [['movie', 'artist', 'role_name']]
    
    def __str__(self):
        role_type = "Hauptrolle" if self.is_main_role else "Nebenrolle"
        return f"{self.artist.full_name} als {self.role_name} in {self.movie.title} ({role_type})"